{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Deep Learning Models -- A collection of various deep learning architectures, models, and tips for TensorFlow and PyTorch in Jupyter Notebooks.\n",
    "- Author: Sebastian Raschka\n",
    "- GitHub Repository: https://github.com/rasbt/deeplearning-models"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sebastian Raschka \n",
      "\n",
      "CPython 3.7.1\n",
      "IPython 7.12.0\n",
      "\n",
      "torch 1.4.0\n",
      "torchvision 0.5.0\n"
     ]
    }
   ],
   "source": [
    "%load_ext watermark\n",
    "%watermark -a 'Sebastian Raschka' -v -p torch,torchvision"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Custom DataLoader for Fashion-MNIST"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The dataset consists of 10 classes similar to the original MNIST dataset. Also, it shares the same overall structure with MNIST, i.e., there are 60k training images and 10k test images, and all images are black & white images of size 28x28. \n",
    "\n",
    "Below is an example of how the images look like:\n",
    "\n",
    "![](figures/fashion-mnist-sprite.png)\n",
    "\n",
    "(Image Source: https://github.com/zalandoresearch/fashion-mnist)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The 10 classes in this dataset are\n",
    "\n",
    "\n",
    "| Label | Description |\n",
    "| --- | --- |\n",
    "| 0 | T-shirt/top |\n",
    "| 1 | Trouser |\n",
    "| 2 | Pullover |\n",
    "| 3 | Dress |\n",
    "| 4 | Coat |\n",
    "| 5 | Sandal |\n",
    "| 6 | Shirt |\n",
    "| 7 | Sneaker |\n",
    "| 8 | Bag |\n",
    "| 9 | Ankle boot |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 1: Downloading the essential files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Download all the necessary files listed in this table **and put them into the folder where this Jupyter notebook is located**:\n",
    "    \n",
    "    \n",
    "| Name  | Content | Examples | Size | Link |\n",
    "| --- | --- |--- | --- |--- |\n",
    "| `train-images-idx3-ubyte.gz`  | training set images  | 60,000|26 MBytes | [Download](http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz)|\n",
    "| `train-labels-idx1-ubyte.gz`  | training set labels  |60,000|29 KBytes | [Download](http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz)|\n",
    "| `t10k-images-idx3-ubyte.gz`  | test set images  | 10,000|4.3 MBytes | [Download](http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz)|\n",
    "| `t10k-labels-idx1-ubyte.gz`  | test set labels  | 10,000| 5.1 KBytes | [Download](http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz)|\n",
    "    \n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "import urllib\n",
    "\n",
    "\n",
    "files = ('train-images-idx3-ubyte.gz', 'train-labels-idx1-ubyte.gz', \n",
    "         't10k-images-idx3-ubyte.gz', 't10k-labels-idx1-ubyte.gz')\n",
    "\n",
    "for file in files:\n",
    "\n",
    "    filedata = urllib.request.urlopen(f'http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/{file}')\n",
    "    datatowrite = filedata.read()\n",
    "\n",
    "    with open(file, 'wb') as f:\n",
    "        f.write(datatowrite)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 2: Unzipping"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, run this code cell to unzip the .gz files."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# this code cell unzips the .gz files\n",
    "\n",
    "import sys\n",
    "import gzip\n",
    "import shutil\n",
    "import os\n",
    "\n",
    "writemode = 'wb'\n",
    "zipped_mnist = [f for f in os.listdir() if f.endswith('ubyte.gz')]\n",
    "for z in zipped_mnist:\n",
    "    with gzip.GzipFile(z, mode='rb') as decompressed, open(z[:-3], writemode) as outfile:\n",
    "        outfile.write(decompressed.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 3: Loading the files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, load the images into NumPy arrays by executing the following function:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Rows: 60000, columns: 784\n",
      "Rows: 10000, columns: 784\n"
     ]
    }
   ],
   "source": [
    "import os\n",
    "import struct\n",
    "import numpy as np\n",
    " \n",
    "def load_mnist(path, kind='train'):\n",
    "    \"\"\"Load data from `path`\"\"\"\n",
    "    labels_path = os.path.join(path, \n",
    "                               '%s-labels-idx1-ubyte' % kind)\n",
    "    images_path = os.path.join(path, \n",
    "                               '%s-images-idx3-ubyte' % kind)\n",
    "        \n",
    "    with open(labels_path, 'rb') as lbpath:\n",
    "        magic, n = struct.unpack('>II', \n",
    "                                 lbpath.read(8))\n",
    "        labels = np.fromfile(lbpath, \n",
    "                             dtype=np.uint8)\n",
    "\n",
    "    with open(images_path, 'rb') as imgpath:\n",
    "        magic, num, rows, cols = struct.unpack(\">IIII\", \n",
    "                                               imgpath.read(16))\n",
    "        images = np.fromfile(imgpath, \n",
    "                             dtype=np.uint8).reshape(len(labels), 784)\n",
    " \n",
    "    return images, labels\n",
    "\n",
    "\n",
    "X_train, y_train = load_mnist('', kind='train')\n",
    "print('Rows: %d, columns: %d' % (X_train.shape[0], X_train.shape[1]))\n",
    "\n",
    "X_test, y_test = load_mnist('', kind='t10k')\n",
    "print('Rows: %d, columns: %d' % (X_test.shape[0], X_test.shape[1]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 10 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig, ax = plt.subplots(nrows=2, ncols=5, sharex=True, sharey=True)\n",
    "ax = ax.flatten()\n",
    "for i in range(10):\n",
    "    img = X_train[y_train == i][0].reshape(28, 28)\n",
    "    ax[i].imshow(img, cmap='Greys')\n",
    "\n",
    "ax[0].set_xticks([])\n",
    "ax[0].set_yticks([])\n",
    "plt.tight_layout()\n",
    "# plt.savefig('images/12_5.png', dpi=300)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 4: Saving the images as PNG files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This section will create PNG images from the NumPy arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "from PIL import Image"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "if not os.path.exists('png-files'):\n",
    "    os.mkdir('png-files')\n",
    "\n",
    "for idx,row in enumerate(X_train):\n",
    "    file_name = f\"{idx}.png\"\n",
    "    file_path = os.path.join('png-files', file_name)\n",
    "    im = Image.fromarray(row.reshape(28, 28))\n",
    "    im.save(file_path)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "for idx,row in enumerate(X_test):\n",
    "    file_name = f\"{X_train.shape[0] + idx}.png\"\n",
    "    file_path = os.path.join('png-files', file_name)\n",
    "    im = Image.fromarray(row.reshape(28, 28))\n",
    "    im.save(file_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "After executing the previous code, you should have 70k images in the `png-files` directory (60k training images and 10k test images)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "70000"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(os.listdir('png-files'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 5: Creating CSV files with class labels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lastly, we are going to create CSV files that contain the image file paths with the images' corresponding class labels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>class_label</th>\n",
       "      <th>image_name</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>9</td>\n",
       "      <td>0.png</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>0</td>\n",
       "      <td>1.png</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>0</td>\n",
       "      <td>2.png</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>3</td>\n",
       "      <td>3.png</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>0</td>\n",
       "      <td>4.png</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   class_label image_name\n",
       "0            9      0.png\n",
       "1            0      1.png\n",
       "2            0      2.png\n",
       "3            3      3.png\n",
       "4            0      4.png"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_train = pd.DataFrame(y_train, columns=['class_label'])\n",
    "df_train['image_name'] = [f\"{idx}.png\" for idx in range(y_train.shape[0])]\n",
    "df_train.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_shuffled = df_train.sample(n=df_train.shape[0], random_state=123)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_trainset = df_shuffled.iloc[:55000]\n",
    "df_validset = df_shuffled.iloc[55000:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>class_label</th>\n",
       "      <th>image_name</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>9</td>\n",
       "      <td>60000.png</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2</td>\n",
       "      <td>60001.png</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>1</td>\n",
       "      <td>60002.png</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>1</td>\n",
       "      <td>60003.png</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>6</td>\n",
       "      <td>60004.png</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "   class_label image_name\n",
       "0            9  60000.png\n",
       "1            2  60001.png\n",
       "2            1  60002.png\n",
       "3            1  60003.png\n",
       "4            6  60004.png"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "df_testset = pd.DataFrame(y_test, columns=['class_label'])\n",
    "df_testset['image_name'] = [f\"{X_train.shape[0]+idx}.png\" for idx in range(y_test.shape[0])]\n",
    "df_testset.head()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_trainset.to_csv('train.csv', index=None)\n",
    "df_validset.to_csv('valid.csv', index=None)\n",
    "df_testset.to_csv('test.csv', index=None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Step 6: Creating the custom Dataset and DataLoader classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from torch.utils.data import Dataset\n",
    "from torchvision import transforms\n",
    "from torch.utils.data import DataLoader\n",
    "import pandas as pd\n",
    "\n",
    "\n",
    "class FashionMNISTDataset(Dataset):\n",
    "    \"\"\"Custom Dataset for loading FashionMNIST images\"\"\"\n",
    "\n",
    "    def __init__(self, csv_path, img_dir, transform=None):\n",
    "    \n",
    "        df = pd.read_csv(csv_path)\n",
    "        self.img_dir = img_dir\n",
    "        self.img_names = df['image_name'].values\n",
    "        self.y = df['class_label'].values\n",
    "        self.transform = transform\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        img = Image.open(os.path.join(self.img_dir,\n",
    "                                      self.img_names[index]))\n",
    "        \n",
    "        if self.transform is not None:\n",
    "            img = self.transform(img)\n",
    "        \n",
    "        label = self.y[index]\n",
    "        return img, label\n",
    "\n",
    "    def __len__(self):\n",
    "        return self.y.shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "custom_train_transform = transforms.Compose([  \n",
    "                                             transforms.ToTensor(),\n",
    "                                             transforms.Normalize(mean=(0.5,), std=(0.5,))\n",
    "])\n",
    "\n",
    "custom_test_transform = transforms.Compose([\n",
    "                                             transforms.ToTensor(),\n",
    "                                             transforms.Normalize(mean=(0.5,), std=(0.5,))\n",
    "])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "BATCH_SIZE = 64"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [],
   "source": [
    "train_dataset = FashionMNISTDataset(csv_path='train.csv',\n",
    "                                    img_dir='png-files/',\n",
    "                                    transform=custom_train_transform)\n",
    "\n",
    "\n",
    "train_loader = DataLoader(dataset=train_dataset,\n",
    "                          batch_size=BATCH_SIZE,\n",
    "                          shuffle=True,\n",
    "                          drop_last=True,\n",
    "                          num_workers=4)\n",
    "\n",
    "\n",
    "valid_dataset = FashionMNISTDataset(csv_path='valid.csv',\n",
    "                                    img_dir='png-files/',\n",
    "                                    transform=custom_test_transform)\n",
    "\n",
    "valid_loader = DataLoader(dataset=valid_dataset,\n",
    "                          batch_size=BATCH_SIZE,\n",
    "                          shuffle=False,\n",
    "                          num_workers=4)\n",
    "\n",
    "\n",
    "test_dataset = FashionMNISTDataset(csv_path='test.csv',\n",
    "                                   img_dir='png-files/',\n",
    "                                   transform=custom_test_transform)\n",
    "\n",
    "test_loader = DataLoader(dataset=test_dataset,\n",
    "                         batch_size=BATCH_SIZE,\n",
    "                         shuffle=False,\n",
    "                         num_workers=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The cell below just checks if the dataset can be loaded correctly."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch: 1 | Batch index: 0 | Batch size: 64\n",
      "break minibatch for-loop\n",
      "Epoch: 2 | Batch index: 0 | Batch size: 64\n",
      "break minibatch for-loop\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "\n",
    "\n",
    "DEVICE = torch.device(\"cuda:0\" if torch.cuda.is_available() else \"cpu\")\n",
    "torch.manual_seed(0)\n",
    "\n",
    "num_epochs = 2\n",
    "for epoch in range(num_epochs):\n",
    "\n",
    "    for batch_idx, (x, y) in enumerate(train_loader):\n",
    "        \n",
    "        print('Epoch:', epoch+1, end='')\n",
    "        print(' | Batch index:', batch_idx, end='')\n",
    "        print(' | Batch size:', y.size()[0])\n",
    "        \n",
    "        x = x.to(DEVICE)\n",
    "        y = y.to(DEVICE)\n",
    "        \n",
    "        print('break minibatch for-loop')\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Visualize some iamges:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 576x576 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import torchvision.utils as vutils\n",
    "\n",
    "batch = next(iter(train_loader))\n",
    "plt.figure(figsize=(8, 8))\n",
    "plt.axis(\"off\")\n",
    "plt.title(\"Training Images\")\n",
    "plt.imshow(np.transpose(vutils.make_grid(batch[0][:64], \n",
    "                                         padding=2, normalize=True),\n",
    "                        (1, 2, 0)))\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
